home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 11 / FM Towns Free Software Collection 11.iso / t_os / game / pr / src / prgrp.c < prev    next >
Text File  |  1995-08-20  |  10KB  |  479 lines
  1. /*=====================================
  2.     "prgrp.c"
  3. =====================================*/
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <msdos.cf>
  7. #include <egb.h>
  8. //#include <concorde.h>
  9. #include <malloc.h>
  10. #include "prdef.h"
  11.  
  12. #define    SKYCOL    C32K(31, 5, 3)
  13. #define    GRDCOL    C32K(10,10,12)
  14.  
  15. short    *vram;        //[VramX*240];
  16. char    *EgbWork;    //[EgbWorkSize];
  17. char    *backBlc;    //[320*240*2];
  18. // PAGE     p1,vp;
  19.  
  20. struct {
  21.     char    *adr;
  22.     short    sel;
  23.     short    sx,sy,ex,ey;
  24. } pbpara;
  25.  
  26. /*******
  27. void filledBox( sx, sy, ex, ey, col )    //    画面外は暴走
  28.     int    sx,sy,ex,ey;
  29.     short col;
  30. {
  31.     short    *vp=vram+sy*VramX+sx;
  32.     int    x=ex-sx,y=ey-sy,i;
  33.     for(; y>=0; --y){
  34.         for(i=x; i>=0; --i)
  35.             *vp++=col ;
  36.         vp+=(VramX-x-1) ;
  37.     }
  38. }
  39. ********/
  40.  
  41. void partClearScr( sy, ey, col )
  42.     int sy,ey;
  43.     short col;
  44. #ifdef HISPEC
  45. {
  46.     short    *vp=vram+sy*VramX;
  47.     int    i=(ey-sy+1)*VramX;
  48.     for(; i>0; --i)
  49.         *vp++ = col;
  50. }
  51. #else
  52. {
  53.     memset( (char *)(vram+sy*VramX), 0, (ey-sy+1)*VramX*2);
  54. }
  55. #endif
  56.     
  57. initGrp()
  58. {
  59.     int    ret=1;
  60.  
  61.     vram = (short *)malloc( sizeof(short)*VramX*240 );
  62.     EgbWork = malloc( EgbWorkSize );
  63.     if( vram==NULL || EgbWork==NULL )
  64.         return -1;
  65.  
  66.     EGB_init( EgbWork, EgbWorkSize );    /* 初期化           */
  67.     EGB_resolution ( EgbWork, 0,10 );    /* 32k(320*240)        */
  68.     EGB_resolution ( EgbWork, 1, 3 );    /* 16 (640*480)        */
  69.     EGB_displayPage( EgbWork, 1, 3 );    /* 表示ページの指定    */
  70.     EGB_displayStart(EgbWork,3,0,0 );    /* 2*2 に拡大        */
  71.     EGB_displayStart(EgbWork,2,2,2 ); 
  72.     EGB_displayStart(EgbWork,1,0,0 );
  73.     EGB_displayStart(EgbWork,3,320,240);
  74.  
  75.     EGB_writePage  ( EgbWork, 1 );
  76.     EGB_writeMode  ( EgbWork, 0    );    /*※描画モードの設定 */
  77.     EGB_paintMode  ( EgbWork, 0x22 );
  78.  
  79.     EGB_textSpace( EgbWork, 1 );
  80.     EGB_fontStyle( EgbWork, 1 );
  81.     EGB_textZoom( EgbWork, 0, 24, 48 );            /* ANK        */
  82.     EGB_textZoom( EgbWork, 1, 32, 32 );            /* 漢字        */
  83.  
  84.     /// YGH_initPage( &p1, SEG_VRAMP,   0x00000, 512,256 );
  85.     /// YGH_initPage( &vp, SEG_VIRTU, ADR(vram), 320,240 );
  86.     /// YGH_color( &vp, 0 );
  87.     /// YGH_filledBox( &vp, 0,0, 319,239 );
  88.     //filledBox( 0,0, 319,239, 0 );
  89.     partClearScr( 0, 239, 0 );
  90.  
  91.     extern initFigImg();
  92.     initFigImg();
  93.  
  94.     extern initBackBlc();
  95.     ret = initBackBlc();
  96.     if( ret<0 ) return ret;
  97.  
  98.     pbpara.adr = (char *)vram ;
  99.     pbpara.sel = getds();
  100.     pbpara.sx = 0;
  101.     pbpara.sy = 0;
  102.     pbpara.ex = 319;
  103.     pbpara.ey = 239;
  104.  
  105.     return 1;
  106. }
  107.  
  108. void writeScreen()
  109. {
  110.     EGB_writePage  ( EgbWork, 0 );
  111.     EGB_putBlock( EgbWork, 0, (char *)&pbpara );
  112.     EGB_writePage  ( EgbWork, 1 );
  113. }
  114.  
  115. initBackBlc()
  116. {
  117.     backBlc = malloc( 320*480*2 );
  118.     if( backBlc==NULL ){
  119.         puts("メモリが足りません(initBackBlc)");
  120.         return -1;
  121.     }
  122.  
  123.     FILE    *fp;
  124.     fp = fopen("back.blc","rb");
  125.     if (fp==NULL) {
  126.         puts("'back.blc'のオープンに失敗しました｡");
  127.         return 0;
  128.     }
  129.  
  130.     fread(backBlc,1,320*480*2,fp);
  131.     return 0;
  132. }
  133.  
  134. void
  135. clearVram( a, b, c )
  136.     int a,b,c ;
  137. {
  138. #if HeadY!=0
  139.     /// YGH_color( &vp, FRMCOL );
  140.     /// YGH_filledBox( &vp, 0, 0, VramX-1, HeadY-1 );
  141.     //filledBox( 0, 6, VramX-1, 9, FRMCOL );
  142.     partClearScr( 6, 9, FRMCOL );
  143. #endif
  144.     int y = 240-SbjY-Mag*b/c ;
  145.     y = _max(0,y);
  146.     y = _min(480-VramY,y);
  147.     memcpy( (char *)(vram+320*HeadY), backBlc+320*y*2, 320*VramY*2 );
  148. }
  149.  
  150. //    凸多角形専用 ２Ｄポリゴン　v2.0    95.7
  151. #define py(a) pt[2*(a)+1]
  152. #define px(a) pt[2*(a)]
  153. void polygon( pol2d *pd )
  154. {
  155.     int    n=pd->n;
  156.     int    *pt=((int *)pd)+1;
  157.     short col=pd->col;
  158.     int    sy, ey, up;
  159.     int    y;
  160.     int    x0, n0, m0, dy0, dx0, ax0;
  161.     int    x1, n1, m1, dy1, dx1, ax1;
  162.     short    *vy;
  163.  
  164.     up=0;
  165.     sy=py(0); ey=py(0);
  166.     for(y=1; y<n; ++y)
  167.     {
  168.         if( sy > py(y) ){
  169.             sy = py(y);
  170.             up = y;
  171.         }
  172.         ey = _max(ey,py(y));
  173.     }
  174.     ey = _min(ey,VramY-1);
  175.     x0 = x1 = px(up);
  176.     n0 = n1 = up;
  177.     m0 = (up+n-1)%n;
  178.     m1 = (up+1)%n;
  179.     dx0 = px(m0) - px(n0);    dy0 = py(m0)-py(n0);
  180.     dx1 = px(m1) - px(n1);    dy1 = py(m1)-py(n1);
  181.     ax0 = x0 * dy0;            ax1 = x1 * dy1;
  182.     vy = ( sy>=0 ? vram+sy*VramX+HeadY*VramX : NULL );
  183.     for( y=sy; y<=ey; ++y )
  184.     {
  185.         //    左周りの ｘ
  186.         if( py(m0)<=y ){
  187.             n0 = m0;    m0 = (m0+n-1)%n;
  188.             dx0 = px(m0)-px(n0); dy0 = py(m0)-py(n0);
  189.             ax0 = px(n0) * dy0;
  190.         }
  191.         if( dy0==0 )
  192.             x0 = px(n0);
  193.         else{
  194.             x0 = ax0 / dy0;
  195.             ax0 += dx0;
  196.         }
  197.         //    右周りの ｘ
  198.         if( py(m1)<=y ){
  199.             n1 = m1;    m1 = (m1+1)%n;
  200.             dx1 = px(m1)-px(n1); dy1 = py(m1)-py(n1);
  201.             ax1 = px(n1) * dy1;
  202.         }
  203.         if( dy1==0 )
  204.             x1 = px(n1);
  205.         else{
  206.             x1 = ax1 / dy1;
  207.             ax1 += dx1;
  208.         }
  209.         //    描画
  210.         if( vy==NULL && y==0 ) vy = vram+VramX*HeadY;
  211.         if( vy!=NULL ){
  212.             up = _max(_min(x0,x1),  0);
  213.             sy = _min(_max(x0,x1),319);    sy -= up;
  214.             register short *vp = vy; vp += up;
  215.             for(; 0<=sy; ++vp,--sy) *vp = col;
  216.             vy += VramX;
  217.         }
  218.     }
  219. }
  220.  
  221. /*======================================
  222.     "prolpdsp.c" ( Overlap Display )
  223. ======================================*/
  224. extern rdata    *road; //[POLMAX]
  225. extern int pflap;
  226. extern short polmax,rd, blap[],flap[];
  227.  
  228. void textputs( char *s, int x, int y, int mode, int colc, int colb)
  229. {
  230.     char    para[256];
  231.     EGB_color( EgbWork, 0, colc );
  232.     EGB_color( EgbWork, 1, colb );
  233.     EGB_paintMode( EgbWork, 0x022 );
  234.     EGB_writeMode( EgbWork, mode );
  235.     WORD(para+0) = x;    WORD(para+2) = y;
  236.     WORD(para+4) = strlen(s);
  237.     strcpy( para+6, s );
  238.     EGB_sjisString( EgbWork, para );
  239. }
  240.  
  241. void putMess( char *str, int col )
  242. {
  243.     EGB_textZoom( EgbWork, 0, 24, 48 );    //    ANK
  244. //    EGB_writePage( EgbWork, 1 );
  245.     textputs( str, 320-13*25/2,250, 0, col, 0 );
  246. //    EGB_writePage( EgbWork, 0 );
  247. }
  248.  
  249. void putLapTime( int lap, int time, int best )
  250. {
  251.     int    m, s, cs;
  252.     static char    str[50];
  253.     if( lap>0 )
  254.     {
  255.         m = time/6000;
  256.         cs= time%100;
  257.         s =(time-m*6000)/100;
  258.         sprintf(str,"LAP%1d %2d:%02d.%02d",lap,m,s,cs);
  259.         EGB_textZoom( EgbWork, 0, 8, 16 );    //    ANK
  260. //        EGB_writePage( EgbWork, 1 );
  261.         textputs(str,640-8*20,lap*20+47,0,(time<=best ? 10:13),0);
  262.     }
  263.     else
  264.         sprintf(str,"    START    ");
  265.     putMess( str,14 );
  266. }
  267.  
  268. void boxfil( int x1, int y1, int x2, int y2,/* int mode,*/ int col)
  269. {
  270.     char    para[8];
  271.     EGB_color( EgbWork, 2, col );    /* 2:FILL color */
  272.     EGB_paintMode( EgbWork, 0x20 );
  273. //    EGB_writeMode( EgbWork, mode );
  274.     WORD(para+0) = x1;    WORD(para+2) = y1;
  275.     WORD(para+4) = x2;    WORD(para+6) = y2;
  276.     EGB_rectangle( EgbWork, para );
  277.     EGB_paintMode( EgbWork, 0x22 );
  278. }
  279.  
  280. void clearMess()
  281. {
  282. //    EGB_writePage( EgbWork, 1 );
  283.     boxfil( 320-13*25/2,250-48, 320+15*25/2,250,0);
  284. //    EGB_writePage( EgbWork, 0 );
  285. }
  286.  
  287. void clearScreen()
  288. {
  289. //    EGB_writePage( EgbWork, 1 );
  290.     boxfil(0,0,639,479,0);
  291. //    EGB_writePage( EgbWork, 0 );
  292. }
  293.  
  294. void putSpd( int spd )
  295. {
  296.     int    i,j;
  297.     short    *vp,*vy=vram+VramX*6+20;
  298.     for(i=4; i>0; --i){
  299.         vp=vy;
  300.         for(j=0; j<spd; ++j,++vp)
  301.             *vp = C32K(0,_min(31,j/10),_max(31-j/10,0));
  302.         vy+=320;
  303.     }
  304. }
  305.  
  306. void putlmap()
  307. {
  308.     int    i, j;
  309.     struct {
  310.         unsigned short    num;
  311.         short    p[8];
  312.     } pol;
  313.     pol.num = 4;
  314.  
  315. //    EGB_writePage( EgbWork, 1 );
  316.     EGB_color( EgbWork, 2, 15 );
  317.     EGB_paintMode( EgbWork, 0x20 );
  318.     for(i=0; i<rd; ++i){
  319.         for(j=0; j<4; ++j){
  320.             pol.p[2*j  ] = road[i].px[j] /80;    // dot/20000
  321.             pol.p[2*j+1] = road[i].py[j] /80;
  322.         }
  323.         EGB_color( EgbWork, 2, 15 );
  324.         EGB_polygon( EgbWork, &pol );
  325.     }
  326.     EGB_paintMode( EgbWork, 0x22 );
  327. //    EGB_writePage( EgbWork, 0 );
  328. }
  329.  
  330. void    putLap( short *lap, char *str1, char *str2 )
  331. {
  332.     int  i,j, m,cs,s;
  333.     char lstr[50];
  334.  
  335.     EGB_textZoom( EgbWork, 0, 16, 32 );    //    ANK
  336. //    EGB_writePage( EgbWork, 1 );
  337.     textputs( str2, 320-17*13/2,34+33+34,0,12,0 );
  338.     textputs( str1, 320-17*13/2, 4+33+34,0,12,0 );
  339.     for(i=0,j=1; i<10; ++i)
  340.     {
  341.         if( i!=0 && lap[i-1]!=lap[i] ) j=i+1;
  342.         m=lap[i]/6000;
  343.         cs=lap[i]%100;
  344.         s=(lap[i]-m*6000)/100;
  345.         sprintf( lstr,"%2d.%2d:%02d.%02d",j,m,s,cs );
  346.         textputs( lstr, 320-17*11/2,(i+2)*34+33+34,0,
  347.                   /*(lap[i]==pblap&&lap==blap)||*/
  348.                   (lap[i]==pflap&&lap==flap) ? 15:13,0
  349.                 );
  350.     }        
  351. //    EGB_writePage( EgbWork, 0 );
  352. }
  353.  
  354. /*====================
  355.     タイトル表示
  356. ====================*/
  357. #define    TITLEFILE "title.blc"
  358. #define    TITLEX 640
  359. #define    TITLEY 120
  360. #define    TITLESIZE (TITLEX*TITLEY/8)
  361. static char title[TITLESIZE];
  362. static int titleRead=0;
  363.  
  364. void readTitle()
  365. {
  366.     FILE    *fp;
  367.     int        i;
  368.     fp = fopen(TITLEFILE,"rb");
  369.     if (fp==NULL) {
  370.         printf("File open error!! '%c'が見つかりません。\n",TITLEFILE);
  371.         return;
  372.     }
  373.     for (i=0; i<TITLESIZE; ++i)
  374.         title[i] = getc(fp);
  375.     fclose(fp);
  376. }
  377.  
  378. void putTitle( short col )
  379. {
  380.     if (!titleRead)
  381.     {
  382.         readTitle();
  383.         titleRead = 1;
  384.     }
  385.     struct {
  386.         char *bp ;
  387.         short sel ;
  388.         short sx,sy,ex,ey ;
  389.     } p ;          /* EGB_putBlockのパラメータ */
  390.     p.bp = title ;
  391.     p.sel = getds() ;
  392.  
  393. //    EGB_writePage( EgbWork, 1 );
  394. //    EGB_paintMode( EgbWork, 0x22 );
  395.  
  396.     p.sx = 4 ;
  397.     p.ex = TITLEX-1 +4 ;
  398.     p.sy = 240-TITLEY/2+4 ;
  399.     p.ey = p.sy+TITLEY-1 ;
  400.     EGB_color( EgbWork, 0, 8 );
  401.     EGB_putBlockColor( EgbWork, 0, (char *)&p ) ;
  402.  
  403.     p.sx = 0 ;
  404.     p.ex = TITLEX -1 ;
  405.     p.sy = 240-TITLEY/2 ;
  406.     p.ey = p.sy+TITLEY -1 ;
  407.     EGB_color( EgbWork, 0, col );
  408.     EGB_putBlockColor( EgbWork, 0, (char *)&p ) ;
  409.  
  410. //    EGB_writePage( EgbWork, 0 );
  411. }
  412.  
  413. /*=====================
  414.     Rest Time 表示
  415. =====================*/
  416. #define FIGFILE "fig0.blc"
  417. #define FIGX 32
  418. #define FIGY 48
  419. #define FBUFSIZ (FIGX*FIGY/8)
  420. static char fbuf[10][FBUFSIZ];
  421. static int _CRestTime=-1;
  422.  
  423. static struct {
  424.     char *bp ;
  425.     short sel ;
  426.     short sx,sy,ex,ey ;
  427. } fpara ;
  428.  
  429. initFigImg()
  430. {
  431.     FILE *fp;
  432.     fp = fopen(FIGFILE,"rb");
  433.     if (fp==NULL) {
  434.         puts("'%c'のオープンに失敗しました｡");
  435.         return 0;
  436.     }
  437.     int i,j;
  438.     for(j=0; j<=9; ++j)
  439.         for(i=0; i<FBUFSIZ; ++i)
  440.             fbuf[j][i] = getc(fp);
  441.     fclose(fp);
  442.  
  443.     fpara.sel = getds() ;
  444.     fpara.sy = 48 ;
  445.     fpara.ey = 95 ;
  446. }
  447.  
  448. void putRestTime( int rt )
  449. {
  450.     if (rt==_CRestTime) return;
  451.     if (rt<0){
  452.         _CRestTime = -1;
  453.         return;
  454.     }
  455.  
  456. //    EGB_writePage( EgbWork, 1 );
  457. //    EGB_paintMode( EgbWork, 0x22 );
  458.     EGB_writeMode( EgbWork, 9    );
  459.     EGB_color( EgbWork, 0, 14 );
  460.  
  461.     if(rt/10!=_CRestTime/10 || _CRestTime<0){
  462.         fpara.sx = 320-FIGX ;
  463.         fpara.ex = 320-1 ;
  464.         fpara.bp = &fbuf[(rt/10)%10][0] ;
  465.         EGB_putBlockColor( EgbWork, 0, (char *)&fpara );
  466.     }
  467.     if(rt%10!=_CRestTime%10 || _CRestTime<0){
  468.         fpara.sx = 320 ;
  469.         fpara.ex = 320+FIGX-1 ;
  470.         fpara.bp = &fbuf[rt%10][0] ;
  471.         EGB_putBlockColor( EgbWork, 0, (char *)&fpara );
  472.     }
  473.  
  474.     EGB_writeMode( EgbWork, 9    );
  475. //    EGB_writePage( EgbWork, 0 );
  476.  
  477.     _CRestTime = rt;
  478. }
  479.